Şimdi başlat

"the script" için komut dosyalarını ara

Matrix Library (Linear Algebra, incl Multiple Linear Regression)What's this all about? Ever since 1D arrays were added to Pine Script, many wonderful new opportunities have opened up. There has been a few implementations of matrices and matrix math (most notably by TradingView-user tbiktag in his recent Moving Regression script: ). However, so far, no comprehensive libraries for matrix math and linear algebra has been developed. This script aims to change that. I'm not math expert, but I like learning new things, so I took it upon myself to relearn linear algebra these past few months, and create a matrix math library for Pine Script. The goal with the library was to make a comprehensive collection of functions that can be used to perform as many of the standard operations on matrices as possible, and to implement functions to solve systems of linear equations. The library implements matrices using arrays, and many standard functions to manipulate these matrices have been added as well. The main purpose of the library is to give users the ability to solve systems of linear equations (useful for Multiple Linear Regression with K number of independent variables for example), but it can also be used to simulate 2D arrays for any purpose. So how do I use this thing? Personally, what I do with my private Pine Script libraries is I keep them stored as text-files in a Libraries folder, and I copy and paste them into my code when I need them. This library is quite large, so I have made sure to use brackets in comments to easily hide any part of the code. This helps with big libraries like this one. The parts of this script that you need to copy are labeled "MathLib", "ArrayLib", and "MatrixLib". The matrix library is dependent on the functions from these other two libraries, but they are stripped down to only include the functions used by the MatrixLib library. When you have the code in your script (pasted somewhere below the "study()" call), you can create a matrix by calling one of the constructor functions. All functions in this library start with "matrix_", and all constructors start with either "create" or "copy". I suggest you read through the code though. The functions have very descriptive names, and a short description of what each function does is included in a header comment directly above it. The functions generally come in the following order: Constructors: These are used to create matrices (empy with no rows or columns, set shape filled with 0s, from a time series or an array, and so on). Getters and setters: These are used to get data from a matrix (like the value of an element or a full row or column). Matrix manipulations: These functions manipulate the matrix in some way (for example, functions to append columns or rows to a matrix). Matrix operations: These are the matrix operations. They include things like basic math operations for two indices, to transposing a matrix. Decompositions and solvers: Next up are functions to solve systems of linear equations. These include LU and QR decomposition and solvers, and functions for calculating the pseudo-inverse or inverse of a matrix. Multiple Linear Regression: Lastly, we find an implementation of a multiple linear regression, including all the standard statistics one can expect to find in most statistical software packages. Are there any working examples of how to use the library? Yes, at the very end of the script, there is an example that plots the predictions from a multiple linear regression with two independent (explanatory) X variables, regressing the chart data (the Y variable) on these X variables. You can look at this code to see a real-world example of how to use the code in this library. Are there any limitations? There are no hard limiations, but the matrices uses arrays, so the number of elements can never exceed the number of elements supported by Pine Script (minus 2, since two elements are used internally by the library to store row and column count). Some of the operations do use a lot of resources though, and as a result, some things can not be done without timing out. This can vary from time to time as well, as this is primarily dependent on the available resources from the Pine Script servers. For instance, the multiple linear regression cannot be used with a lookback window above 10 or 12 most of the time, if the statistics are reported. If no statistics are reported (and therefore not calculated), the lookback window can usually be extended to around 60-80 bars before the servers time out the execution. Hopefully the dev-team at TradingView sees this script and find ways to implement this functionality diretly into Pine Script, as that would speed up many of the operations and make things like MLR (multiple linear regression) possible on a bigger lookback window. Some parting words This library has taken a few months to write, and I have taken all the steps I can think of to test it for bugs. Some may have slipped through anyway, so please let me know if you find any, and I'll try my best to fix them when I have time to do so. This library is intended to help the community. Therefore, I am releasing the library as open source, in the hopes that people may improving on it, or using it in their own work. If you do make something cool with this, or if you find ways to improve the code, please let me know in the comments.
Pine Script® göstergesi
lejmer tarafından
21
EMA TrendThe purpose of this script is to identify price trends based on EMAs. The relative position of price to specific EMAs and the position of certain EMAs towards each other are used to determine the trend direction. The script is intended for investors as a tool to define a basis for further evaluation. I do not use the script as a signal generator and would not recommend doing so without the help of additional indicators. How to work with the script The major (or long term) trend direction is determined by the 144 EMA much in the same way as the 200 MA is used in other systems. If the price is above the 144 EMA we are in a long term uptrend, below we are in a long term downtrend. This is to be taken with a grain of salt though. The 144 EMA is considerably shorter than the 200 SMA and is more prone to the price fluctuating around it during periods without a strong long term trend. I recommend using this as a confirmation for the short term trend. The short term trend is derived from the position and slope of the price, the 21 EMA and the 55 EMA. If the price is above the 21 EMA, the 21 above the 55 EMA, both EMAs are sloping upwards and the distance between the two is increasing, we are talking about an uptrend (and vice versa for a downtrend). This is visualized by the color of the fill between the 144 EMA and close price. Green for uptrend, red for downtrend and no color for an undetermined trend. The EMAs used are: 21 , 34 , 55 , 89 , 144 , 233 . Most of the EMAs are at 50 transparency to appear less dominant. For orientation, the 144 EMA is bright green to indicate its general importance for the trend determination, and the 55 EMAs is not transparent mainly to be able to identify positioning when the EMAs are close together. Base time frame EMA The 144 EMA is plotted twice where one is fixed to the daily time frame (can be configured) to be able to have the 144 on different timeframes during analysis. I find this very useful to keep the focus on my main time frame while analyzing trend on lower or higher time frames. This can also be turned off. Configurability This script is less configurable than I generally like with my other scripts. The reason is that the title attribute of the plots is not dynamic, and I use the data window often to get exact values from the script to determine buy targets for pullbacks and other things. Hence, I prefer not to have random names (or no names) in there to save mental capacity. If this ever becomes available, I'll gladly add this to this script. Till then, I encourage you to take the script and adjust it to your own needs. It should be simple enough even if you are just starting out in pine.
Pine Script® göstergesi
AshDollmaker tarafından
[PX] External LevelHello everyone, today I'd like to share a script, which enables you to use external logic to plot levels on your chart. How does it work? The concept is based on two scripts. One script, which uses an external input as a trigger to print a new level and one script that calculates an output, which will be fetched. Sounds complicated? It really is not! Let's take a closer look. // This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org // © paaax //@version=4 study("RSI OS/OB") l = input(14, "RSI Length") ob = input(70, "Overbought") os = input(30, "Oversold") r = rsi(close, l) hline(ob) hline(os) plot(r, "RSI", color=color.orange) // The following plot produces an output, which will be fetched the "External Level"-script. // It evaluates to one of the following three values: 1.0, -1.0 or 0.0 plot(crossover(r, ob) ? 1.0 : crossunder(r, os) ? -1.0 : 0.0, "Output", transp=100) The example script above uses an RSI and two threshold levels (70 and 30). The logic here is, that whenever the RSI is crossing down the lower threshold or crossing up the upper threshold we'd consider the current movement to be either oversold or overbought. Therefore, it's a point of interest, which we could visualize with a level. The script creates an output when the crossover or crossunder of a threshold happens. A crossover would result in a value of 1.0, a crossunder in a value of -1.0. In all other cases the value would be 0.0. The output of the RSI script would then be used as an input of the External Level script, which has a "Source"-parameter in its input-section. If the fetched input shows 1.0, then the script prints a resistance level. If it shows -1.0 a support level will be printed. And that's basically it. A very simple approach to print levels on your chart with an infinite number of use cases. For example, you could use fetch outputs from a MACD script, MA script, outputs based on volume or price movement. Just remember the output has to evaluate to either 1.0 or -1.0 and has to be selected in the input-section. Hope that might be useful to some of you :) Please click the "Like"-button and follow me for future open-source script publications. If you are looking for help with your custom PineScript development, don't hesitate to contact me directly here on Tradingview or through the link in my signature :)
Pine Script® göstergesi
paaax tarafından
52
Business Cycle Indicators (Normalized)This script aggregates and normalizes several key economic indicators to provide a comprehensive view of the business cycle and overall market conditions. By combining these indicators into a single, normalized average line, the script helps identify overarching trends and shifts in the economy, aiding in more informed trading and investment decisions. Included Indicators: Inverted National Financial Conditions Index (NFCI): Symbol: FRED:NFCI Measures financial stress in the markets. An inverted NFCI aligns higher values with positive financial conditions. Inverted Net Percentage of Banks Tightening Lending Standards (DRTSCIS): Symbol: FRED:DRTSCIS Reflects changes in bank lending practices. Inverting this indicator means higher values indicate easing lending standards, which is generally positive for economic growth. HYG Close Price (iShares High Yield Corporate Bond ETF): Symbol: AMEX:HYG Represents the performance of high-yield corporate bonds, providing insight into credit market conditions. Inverted High-Yield Credit Spread (BAMLH0A0HYM2): Symbol: FRED:BAMLH0A0HYM2 Measures the spread between high-yield bonds and risk-free securities. A narrower (inverted) spread indicates better market conditions. Manufacturing/Non-Manufacturing New Orders Ratio: Symbols: ECONOMICS:USMNO (Manufacturing), ECONOMICS:USNMNO (Non-Manufacturing) Compares manufacturing to non-manufacturing new orders to gauge shifts in economic activity. US PMI (Purchasing Managers' Index): Symbol: ECONOMICS:USBCOI An indicator of the economic health of the manufacturing sector. 10-Year Inflation Breakeven (T10YIE): Symbol: FRED:T10YIE Represents market expectations of inflation over the next ten years. Inverted 10-Year Real Yield (DFII10): Symbol: FRED:DFII10 Reflects the real yield on 10-year Treasury Inflation-Protected Securities (TIPS). Inverted to align higher values with positive economic sentiment. Copper/Gold Ratio: Symbols: CAPITALCOM:COPPER (Copper), TVC:GOLD (Gold) Compares the prices of copper and gold, often used as a barometer for global economic activity. Features: Normalized Indicators: Each indicator is normalized to a 0-100 scale to facilitate direct comparison, regardless of their original units or scales. Normalized Average Line: Calculates and plots the average of all available normalized indicators, providing a single line that represents the combined economic signals. Customizable Display: Show Individual Indicators: Option to display individual normalized indicators for detailed analysis. Show Normalized Average Line: Option to display the normalized average line for a consolidated view. Dynamic Labeling: Displays the latest value of the normalized average directly on the chart for quick reference. How to Use: Adding the Script: Apply the script to a chart in TradingView using a timeframe that aligns with the frequency of the economic data (daily or weekly recommended). Customization: Show Normalized Average Line: Enabled by default to display the combined indicator. Show Individual Indicators: Enable this option in the script settings to display all individual normalized indicators. Interpretation: Normalized Scale (0-100): Higher values generally indicate stronger economic conditions, while lower values may suggest weakening conditions. Trend Analysis: Use the normalized average line to identify trends and potential turning points in the business cycle. Notes: Data Availability: Ensure you have access to all the data sources used in the script. Some data feeds may require specific TradingView subscriptions. Indicator Limitations: Economic indicators are subject to revisions and may not reflect real-time market conditions. No Investment Advice: This script is a tool for analysis and should not be considered as financial advice. Always conduct your own research before making investment decisions.
Pine Script® göstergesi
aussiemcbull tarafından
1
Advanced Volume-Driven Breakout SignalsThe "Advanced Volume-Driven Breakout Signals" indicator is a cutting-edge tool designed to help traders identify high-potential trading opportunities through sophisticated volume analysis techniques. This indicator integrates volume flow analysis, moving averages, and Relative Volume (RVOL) to provide a comprehensive view of market conditions, going beyond traditional Volume Spread Analysis (VSA) methods. Key Features: Volume Flow Analysis: Distinguishes bullish and bearish volume flows with distinct colors, making it easier to visualize market sentiment and potential breakout points. Volume Flow Moving Averages: Calculates moving averages for volume using various methods (SMA, EMA, WMA, HMA, VWMA), accommodating different trading strategies. This includes settings for adjusting the type of moving average and its period, as well as thresholds for high, medium, and low volume levels. Volume Spikes Detection: Identifies significant volume spikes based on user-defined multipliers and moving averages, highlighting unusual trading activity. Volume MA Cloud Settings: Computes general moving averages of volume to track trends and detect deviations. This feature includes options to select different moving average types and adjust thresholds for detecting high volume activity. Relative Volume (RVOL): Measures current volume relative to historical averages, triggering signals when RVOL exceeds predefined thresholds, indicating notable changes in trading activity. Entry Conditions: Provides clear long and short entry signals based on combined volume flow conditions and RVOL, offering actionable trading opportunities. Volume Visualization: — Bullish Volume Flow: Light and dark green bars indicate bullish volume flow. — Bearish Volume Flow: Light and dark red bars denote bearish volume flow. — High Volume Bars: Highlighted in yellow, and extreme volume bars in orange for additional context. These bars are plotted for visual aid and do not directly influence trade signals, focusing instead on the quality and strength of the volume flow. Alerts: Allows users to create alert notifications for long and short entry signals when the criteria are met, enabling traders to respond promptly to trading opportunities. Usage: Overlay: Apply the indicator directly to your price chart to visualise real-time signals and volume conditions. Customisable: Adjust settings for moving averages, RVOL, and other parameters to match your trading strategy and preferences. Comparison to VSA Scripts: The "Advanced Volume-Driven Breakout Signals" indicator extends beyond traditional VSA scripts by incorporating a wider range of analytical features. While VSA primarily focuses on volume spread patterns and price action, this indicator offers enhanced functionality with advanced RVOL metrics, customizable moving averages, and detailed volume spike detection, making it a more versatile tool for identifying breakout opportunities and managing trades. It is particularly effective when used alongside key levels and order blocks. Acknowledgements: Special thanks to @oh92 and @goofoffgoose for their invaluable scripts, which served as inspiration in the development of this advanced trading indicator. Notes: The script is continually evolving, with ongoing refinements aimed at enhancing accuracy and performance.
Pine Script® göstergesi
VolumeVigilante tarafından
[SGM GARCH Volatility]I'm excited to share with you a Pine Script™ that I developed to analyze GARCH (Generalized Autoregressive Conditional Heteroskedasticity) volatility. This script allows you to calculate and plot GARCH volatility on TradingView. Let's see together how it works! Introduction Volatility is a key concept in finance that measures the variation in prices of a financial asset. The GARCH model is a statistical method that predicts future volatility based on past volatilities and prediction residuals (errors). Indicator settings We define several parameters for our indicator: length = input.int(20, title="Length") p = input.int(1, title="Lag order (p)") q = input.int(1, title="Degree of moving average (q)") cluster_value = input(0.2,title="cluster value") length: The period used for the calculations, default 20. p: The order of the delay for the GARCH model. q: The degree of the moving average for the GARCH model. cluster_value: A threshold value used to color the graph. Calculation of logarithmic returns We calculate logarithmic returns to capture price changes: logReturns = math.log(close) - math.log(close ) Initializing arrays We initialize arrays to store residuals and volatilities: var float residuals = array.new_float(length, 0) var float volatilities = array.new_float(length, 0) We add the new logarithmic returns to the tables and keep their size constant: array.unshift(residuals, logReturns) if (array.size(residuals) > length) array.pop(residuals) We then calculate the mean and variance of the residuals: meanResidual = array.avg(residuals) varianceResidual = array.stdev(residuals, meanResidual) volatility = math.sqrt(varianceResidual) We update the volatility table with the new value: array.unshift(volatilities, volatility) if (array.size(volatilities) > length) array.pop(volatilities) GARCH volatility is calculated from accumulated data: var float garchVolatility = na if (array.size(volatilities) >= length and array.size(residuals) >= length) alpha = 0.1 // Alpha coefficient beta = 0.85 // Beta coefficient omega = 0.01 // Omega constant sumVolatility = 0.0 for i = 0 to p-1 sumVolatility := sumVolatility + beta * math.pow(array.get(volatilities, i), 2) sumResiduals = 0.0 for j = 0 to q-1 sumResiduals := sumResiduals + alpha * math.pow(array.get(residuals, j), 2) garchVolatility := math.sqrt(omega + sumVolatility + sumResiduals) Plot GARCH volatility We finally plot the GARCH volatility on the chart and add horizontal lines for easier visual analysis: plt = plot(garchVolatility, title="GARCH Volatility", color=color.rgb(33, 149, 243, 100)) h1 = hline(0.1) h2 = plot(cluster_value) h3 = hline(0.3) colorGarch = garchVolatility > cluster_value ? color.red: color.green fill(plt, h2, color = colorGarch) colorGarch: Determines the fill color based on the comparison between garchVolatility and cluster_value. Using the script in your trading Incorporating this Pine Script™ into your trading strategy can provide you with a better understanding of market volatility and help you make more informed decisions. Here are some ways to use this script: Identification of periods of high volatility: When the GARCH volatility is greater than the cluster value (cluster_value), it indicates a period of high volatility. Traders can use this information to avoid taking large positions or to adjust their risk management strategies. Anticipation of price movements: An increase in volatility can often precede significant price movements. By monitoring GARCH volatility spikes, traders can prepare for potential market reversals or accelerations. Optimization of entry and exit points: By using GARCH volatility, traders can better identify favorable times to enter or exit a position. For example, entering a position when volatility begins to decrease after a peak can be an effective strategy. Adjustment of stops and objectives: Since volatility is an indicator of the magnitude of price fluctuations, traders can adjust their stop-loss and take-profit orders accordingly. Periods of high volatility may require wider stops to avoid being exited from a position prematurely. That's it for the detailed explanation of this Pine Script™ script. Don’t hesitate to use it, adapt it to your needs and share your feedback! Happy analysis and trading everyone!
Pine Script® göstergesi
Sigaud tarafından
2
dashboard MTF,EMA User Guide: Dashboard MTF EMA Script Installation: Copy the script code. Go to the script window (Pine Editor) on TradingView. Paste the code into the script window. Save the script. Adding the Script to the Chart: Return to your chart on TradingView. Look for the script in the list of available scripts. Add the script to the chart. Interpreting the Table: On the right side of the chart, you will see a table labeled "EMA" with arrows. The rows correspond to different timeframes: 5 minutes (5M), 15 minutes (15M), 1 hour (1H), 4 hours (4H), and 1 day (1D). Understanding the Arrows: Each row of the table has two columns: "EMA" and an arrow. "EMA" indicates the trend of the Exponential Moving Average (EMA) for the specified period. The arrow indicates the direction of the trend: ▲ for bullish, ▼ for bearish. Table Colors: The colors of the table reflect the current trend based on the comparison between fast and slow EMAs. Blue (▲) indicates a bullish trend. Red (▼) indicates a bearish trend. Table Theme: The table has a dark (Dark) or light (Light) theme according to your preference. The background, frame, and colors are adjusted based on the selected theme. Usage: Use the table as a quick indicator of trends on different timeframes. The arrows help you quickly identify trends without navigating between different time units. Designed to simplify analysis and avoid cluttering the chart with multiple indicators.
Pine Script® göstergesi
SESE04 tarafından
2
Сoncentrated Market Maker Strategy by oxowlConcentrated Market Maker Strategy by oxowl. This script plots an upper and lower bound for liquidity provision, and checks for rebalancing conditions. It also includes alert conditions for when the price crosses the upper or lower bounds. Here's an overview of the script: It defines the input parameters: liquidity range percentage, rebalance frequency in minutes, and minimum trade size in assets. It calculates the upper and lower bounds for liquidity provision based on the liquidity range percentage. It initializes variables for the last rebalance time and price. It defines a rebalance condition based on the frequency and current price within the specified range. If the rebalance condition is met, it updates the last rebalance time and price. It plots the upper and lower bounds on the chart as lines and adds price labels for both bounds. It defines alert conditions for when the price crosses the upper or lower bounds. Finally, it creates alert conditions with appropriate messages for when the price crosses the upper or lower bounds. Concentrated liquidity is a concept often used in decentralized finance (DeFi) market-making strategies. It allows liquidity providers (LPs) to focus their liquidity within a specific price range, rather than across the entire price curve. Using an indicator with concentrated liquidity can offer several advantages: Increased capital efficiency: Concentrated liquidity allows LPs to allocate their capital within a narrower price range. This means that the same amount of capital can generate more significant price impact and potentially higher returns compared to providing liquidity across a broader range. Customized risk exposure: LPs can choose the price range they feel most comfortable with, allowing them to better manage their risk exposure. By selecting a range based on their market outlook, they can optimize their positions to maximize potential returns. Adaptive strategies: Indicators that support concentrated liquidity can help traders adapt their strategies based on market conditions. For example, they can choose to provide liquidity around a stable price range during low-volatility periods or adjust their range when market conditions change. To continue integrating this script into your trading strategy, follow these steps: Import the script into your TradingView account. Navigate to the Pine editor, paste the code, and save it as a new script. Apply the indicator to a trading pair chart. You can customize the input parameters (liquidity range percentage, rebalance frequency, and minimum trade size) based on your preferences and risk tolerance. Set alerts for when the price crosses the upper or lower bounds. This will notify you when it's time to take action, such as adding or removing liquidity, or rebalancing your position. Monitor the performance of your strategy over time. Adjust the input parameters as needed to optimize your returns and manage risk effectively. (Optional) Integrate the script with a trading bot or automation platform. If you're using an API-based trading solution, you can incorporate the logic and conditions from the script into your bot's algorithm to automate the process of providing concentrated liquidity and rebalancing your positions. Remember that no strategy is foolproof, and past performance is not indicative of future results. Always exercise caution when trading and carefully consider your risk tolerance.
Pine Script® göstergesi
deperp tarafından
[@btc_charlie] Trader XO Macro Trend ScannerWhat is this script? This script has two main functions focusing on EMAs (Exponential Moving Average) and Stochastic RSI. EMAs EMAs are typically used to give a view of bullish / bearish momentum. When the shorter EMA (calculated off more recent price action) crosses, or is above, the slower moving EMA (calculated off a longer period of price action), it suggests that the market is in an uptrend. This can be an indication to either go long on said asset, or that it is more preferable to take long setups over short setups. Invalidation on long setups is usually found via price action (e.g. previous lows) or simply waiting for an EMA cross in the opposite direction (i.e. shorter EMA crosses under longer term EMA). This is not a perfect system for trade entry or exit, but it does give a good indication of market trends. The settings for the EMAs can be changed based on user inputs, and by default the candles are coloured based on the crosses to make it more visual. The default settings are based on “Trader XO’s” settings who is an exceptional swing trader. RSI Stochastic RSI is a separate indicator that has been added to this script. RSI measures Relative Strength (RSI = Relative Strength Index). When RSI is <20 it is considered oversold, and when >80 it is overbought. These conditions suggests that momentum is very strong in the direction of the trend. If there is a divergence between the price (e.g. price is creating higher highs, and stoch RSI is creating lower highs) it suggests the strength of the trend is weakening. Whilst this script does not highlight divergences, what it does highlight is when the shorter term RSI (K) crosses over D (the average of last 3 periods). This can give an indication that the trend is losing strength. Combination The EMAs indicate when trend shifts (bullish or bearish). The RSI indicates when the trend is losing momentum. The combination of the two can be used to suggest when to prefer a directional bias, and subsequently shift in anticipation of a trend reversal. Note that no signal is 100% accurate and an interpretation of market conditions and price action will need to be overlayed to Why is it different to others? I have not found other scripts that are available in this way visually including alerts when Stoch RSI crosses over/under the extremes; or the mid points. Whilst these indicators are default, the combination of them and how they are presented is not and makes use of the TradingView colouring functionalities. What are the features? Customise the variables (averages) used in the script. Display as one EMA or two EMAs (the crossing ones). Alerts on EMA crosses. Alerts on Stoch RSI crosses - slow/fast, upper, lower areas. - Currently set on the chart to show alerts when Stoch RSI is above 80, then falls below 80 (and colours it red). Customisable colours. What are the best conditions for this? It is designed for high timeframe charts and analysis in crypto, since crypto tends to trend. It can however be used for lower timeframes. Disclaimer/Notes: I have noticed several videos appearing suggesting that this is a "100% win rate indicator" . NO indicator has 100% win rate. An indicator is an *indicator* that is all. Please use responsibly and let me know if there are any mods or updates you would like to see.
Pine Script® göstergesi
btc_charlie tarafından
39
Strategy BackTest Display Statistics - TraderHalaiThis script was born out of my quest to be able to display strategy back test statistics on charts to allow for easier backtesting on devices that do not natively support backtest engine (such as mobile phones, when I am backtesting from away from my computer). There are already a few good ones on TradingView, but most / many are too complicated for my needs. Found an excellent display backtest engine by 'The Art of Trading'. This script is a snippet of his hard work, with some very minor tweaks and changes. Much respect to the original author. Full credit to the original author of this script. It can be found here: www.tradingview.com I decided to modify the script by simplifying it down and make it easier to integrate into existing strategies, using simple copy and paste, by relying on existing tradingview strategy backtester inputs. I have also added 3 additional performance metrics: - Max Run Up - Average Win per trade - Average Loss per trade As this is a work in progress, I will look to add in more performance metrics in future, as I further develop this script. Feel free to use this display panel in your scripts and strategies. Thanks and enjoy :)
Pine Script® stratejisi
TraderHalai tarafından
4
logLibrary "log" Logging library for easily displaying debug, info, warn, error and critical messages. No real need to explain why you might want to use this library! I'm sure you've all experienced the frustration of trying to understand the data state of your scripts... so, enjoy! More on it's way... (Don't forget to check the helpers in the script and the useful tips below) Some Useful Tips By default the log console persists between bars (for history) and bars and ticks (for realtime). Sometimes it is useful to clear the log after each candle or tick (assuming we are using the above helpers): ``` log_print(clear = true) // starts afresh on every bar and tick (excludes historical bars but good realtime tick analysis) log_print(clear = barstate.isnew) // clears the log at the start of each bar (again, excludes historical but good realtime candle analysis) ``` It is also useful to be able to selectively understand the state of data at specific points or times within a script: ``` if log.once() debug('useful variable', my_var) // this log only gets written once, upon first execution of this statement if log.only(5) debug3(a, b, c) // these variables are only logged the first five times this statement is executed log_print(clear = false) // clear must be false and you should not write other logs on every bar, or the above will be lost ``` Final tip. If you want to view ONLY log entries of a particular level, then negate the constant: ``` log_print(level = -LOG_DEBUG) ``` Detailed Interface once() Restrict execution to only happen once. Usage: if assert.once()\n happens_once()   Returns: bool, true on first execution within scope, false subsequently only(repeat) Restrict execution to happen a set number of times. Usage: if assert.only(5)\n happens_five_times()   Parameters:      repeat : int, the number of times to return true   Returns: bool, true for the set number of times within scope, false subsequently init() Initialises the log array   Returns: string , tuple based array to contain all pending log entries (__LOG) clear(msgs) Clears the log array   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG) trace(msgs, msg) Writes a trace message to the log console   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      msg : string, the trace message to write to the log debug(msgs, msg) Writes a debug message to the log console   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      msg : string, the debug message to write to the log info(msgs, msg) Writes an info message to the log console   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      msg : string, the info message to write to the log warn(msgs, msg) Writes a warning message to the log console   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      msg : string, the warn message to write to the log error(msgs, msg) Writes an error message to the log console   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      msg : string, the error message to write to the log fatal(msgs, msg) Writes a critical message to the log console   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      msg : string, the fatal message to write to the log log(msgs, level, msg) Write a log message to the log console with a custom level   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      level : ing, the logging level to assign to the message      msg : string, the log message to write to the log severity(msgs) Checks the unprocessed log messages and returns the highest present level   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)   Returns: int, the highest level found within the unfiltered logs print(msgs, level, clear, rows, text_size, position) Prints all log messages to the screen   Parameters:      msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)      level : int, the minimum required log level of each message to be displayed      clear : bool, clear the printed log console after each render (useful with realtime when set to barstate.isconfirmed)      rows : int, the number of rows to display in the log console      text_size : string, the text size of the log console (global size vars)      position : string, the position of the log console (global position vars) unittest_log(case) Log module unit tests, for inclusion in parent script test suite. Usage: log.unittest_log(__ASSERTS)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS) unittest(verbose) Run the log module unit tests as a stand alone. Usage: log.unittest()   Parameters:      verbose : bool, optionally disable the full report to only display failures
Pine Script® kütüphanesi
GeoffHammond tarafından
19
assertLibrary "assert" Production ready assertions and auto-reporting for unit testing pine scripts. This library was born from the need to maintain production level stability and catch regressions / bugs early and fast. I hope this help you trust your pine scripts too. More libraries and tools on their way... please follow for more. Please see the script for helpers to copy into your own scripts as well as examples at the bottom of the library unit testing itself. Quick Reference ``` case = assert.init() new_case(case, 'Asserts for floats and ints') assert.equal(a, b, case, 'a == b') assert.not_equal(a, b, case, 'a != b') assert.nan(a, case, 'a == na') assert.not_nan(a, case, 'a != na') assert.is_in(a, b, case, 'a in b ') assert.is_not_in(a, b, case, 'a not in b ') assert.array_equal(a, b, case, 'a == b ') new_case(case, 'Asserts for ints only') assert.int_in(a, b, case, 'a in b ') assert.int_not_in(a, b, case, 'a not in b ') assert.int_array_equal(a, b, case, 'a == b ') new_case(case, 'Asserts for bools only') assert.is_true(a, case, 'a == true') assert.is_false(a, case, 'a == false') assert.bool_equal(a, b, case, 'a == b') assert.bool_not_equal(a, b, case, 'a != b') assert.bool_nan(a, case, 'a == na') assert.bool_not_nan(a, case, 'a != na') assert.bool_array_equal(a, b, case, 'a == b ') new_case(case, 'Asserts for strings only') assert.str_equal(a, b, case, 'a == b') assert.str_not_equal(a, b, case, 'a != b') assert.str_nan(a, case, 'a == na') assert.str_not_nan(a, case, 'a != na') assert.str_in(a, b, case, 'a in b ') assert.str_not_in(a, b, case, 'a not in b ') assert.str_array_equal(a, b, case, 'a == b ') assert.report(case) ``` Detailed Interface once() Restrict execution to only happen once. Usage: if assert.once()\n happens_once()   Returns: bool, true on first execution within scope, false subsequently init() Initialises the asserts array   Returns: string , tuple based array containing all unit test results and current case details (__ASSERTS) equal(a, b, case, name) Numeric assert equal. Usage: assert.equal(1, 1, case, 'one == one')   Parameters:      a : float, numeric value "a" to compare equal to "b"      b : float, numeric value "b" to compare equal to "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise not_equal(a, b, case, name) Numeric assert not equal. Usage: assert.not_equal(1, 2, case, 'one != two')   Parameters:      a : float, numeric value "a" to compare not equal "b"      b : float, numeric value "b" to compare not equal "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise nan(a, case, name) Numeric assert is NaN. Usage: assert.nan(float(na), case, 'number is NaN')   Parameters:      a : float, numeric value "a" to check is NaN      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise not_nan(a, case, name) Numeric assert is not NaN. Usage: assert.not_nan(1, case, 'number is not NaN')   Parameters:      a : float, numeric value "a" to check is not NaN      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise is_in(a, b, case, name) Numeric assert value in float array. Usage: assert.is_in(1, array.from(1.0), case, '1 is in ')   Parameters:      a : float, numeric value "a" to check is in array "b"      b : float , array "b" to check contains "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise is_not_in(a, b, case, name) Numeric assert value not in float array. Usage: assert.is_not_in(2, array.from(1.0), case, '2 is not in ')   Parameters:      a : float, numeric value "a" to check is not in array "b"      b : float , array "b" to check does not contain "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise array_equal(a, b, case, name) Float assert arrays are equal. Usage: assert.array_equal(array.from(1.0), array.from(1.0), case, ' == ')   Parameters:      a : float , array "a" to check is identical to array "b"      b : float , array "b" to check is identical to array "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise int_in(a, b, case, name) Integer assert value in integer array. Usage: assert.int_in(1, array.from(1), case, '1 is in ')   Parameters:      a : int, value "a" to check is in array "b"      b : int , array "b" to check contains "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise int_not_in(a, b, case, name) Integer assert value not in integer array. Usage: assert.int_not_in(2, array.from(1), case, '2 is not in ')   Parameters:      a : int, value "a" to check is not in array "b"      b : int , array "b" to check does not contain "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise int_array_equal(a, b, case, name) Integer assert arrays are equal. Usage: assert.int_array_equal(array.from(1), array.from(1), case, ' == ')   Parameters:      a : int , array "a" to check is identical to array "b"      b : int , array "b" to check is identical to array "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise is_true(a, case, name) Boolean assert is true. Usage: assert.is_true(true, case, 'is true')   Parameters:      a : bool, value "a" to check is true      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise is_false(a, case, name) Boolean assert is false. Usage: assert.is_false(false, case, 'is false')   Parameters:      a : bool, value "a" to check is false      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise bool_equal(a, b, case, name) Boolean assert equal. Usage: assert.bool_equal(true, true, case, 'true == true')   Parameters:      a : bool, value "a" to compare equal to "b"      b : bool, value "b" to compare equal to "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise bool_not_equal(a, b, case, name) Boolean assert not equal. Usage: assert.bool_not_equal(true, false, case, 'true != false')   Parameters:      a : bool, value "a" to compare not equal "b"      b : bool, value "b" to compare not equal "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise bool_nan(a, case, name) Boolean assert is NaN. Usage: assert.bool_nan(bool(na), case, 'bool is NaN')   Parameters:      a : bool, value "a" to check is NaN      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise bool_not_nan(a, case, name) Boolean assert is not NaN. Usage: assert.bool_not_nan(true, case, 'bool is not NaN')   Parameters:      a : bool, value "a" to check is not NaN      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise bool_array_equal(a, b, case, name) Boolean assert arrays are equal. Usage: assert.bool_array_equal(array.from(true), array.from(true), case, ' == ')   Parameters:      a : bool , array "a" to check is identical to array "b"      b : bool , array "b" to check is identical to array "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_equal(a, b, case, name) String assert equal. Usage: assert.str_equal('hi', 'hi', case, '"hi" == "hi"')   Parameters:      a : string, value "a" to compare equal to "b"      b : string, value "b" to compare equal to "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_not_equal(a, b, case, name) String assert not equal. Usage: assert.str_not_equal('hi', 'bye', case, '"hi" != "bye"')   Parameters:      a : string, value "a" to compare not equal "b"      b : string, value "b" to compare not equal "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_nan(a, case, name) String assert is NaN. Usage: assert.str_nan(string(na), case, 'string is NaN')   Parameters:      a : string, value "a" to check is NaN      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_not_nan(a, case, name) String assert is not NaN. Usage: assert.str_not_nan('hi', case', 'string is not NaN')   Parameters:      a : string, value "a" to check is not NaN      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_in(a, b, case, name) String assert value in string array. Usage: assert.str_in('hi', array.from('hi'), case, '"hi" in ')   Parameters:      a : string, value "a" to check is in array "b"      b : string , array "b" to check contains "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_not_in(a, b, case, name) String assert value not in string array. Usage: assert.str_in('hi', array.from('bye'), case, '"hi" in ')   Parameters:      a : string, value "a" to check is not in array "b"      b : string , array "b" to check does not contain "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise str_array_equal(a, b, case, name) String assert arrays are equal. Usage: assert.str_array_equal(array.from('hi'), array.from('hi'), case, ' == ')   Parameters:      a : string , array "a" to check is identical to array "b"      b : string , array "b" to check is identical to array "a"      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the current unit test name, if undefined the test index of the current case is used   Returns: bool, true if the assertion passes, false otherwise new_case(case, name) Assign a new test case name, for the next set of unit tests. Usage: assert.new_case(case, 'My tests')   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS)      name : string, the case name for the next suite of tests clear(case) Clear all stored unit tests from all cases. Usage: assert.clear(case)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS) revert(case) Revert the previous unit test. Usage: = assert.revert(case)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS)   Returns: , tuple containing the msg and result of the reverted test passed(case, revert) Check if the last unit test has passed. Usage: bool success = assert.passed(case)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS)      revert : bool, optionally revert the test   Returns: bool, true only if the test passed failed(case, revert) Check if the last unit test has failed. Usage: bool failure = assert.failed(case)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS)      revert : bool, optionally revert the test   Returns: bool, true only if the test failed report(case, verbose) Report the outcome of unit tests that fail. Usage: bool passed = assert.report(case)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS)      verbose : bool, optionally display full report that includes the outcome of all tests   Returns: bool, true only if all tests passed unittest_assert(case) Assert module unit tests, for inclusion in parent script test suite. Usage: assert.unittest_assert(__ASSERTS)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS) unittest(verbose) Run the assert module unit tests as a stand alone. Usage: assert.unittest()   Parameters:      verbose : bool, optionally toggle report to display the outcome of all unit tests
Pine Script® kütüphanesi
GeoffHammond tarafından
5
Barholle eMA and RSI Movement TestThis is a test that offers insight into whether and asset is heading into bullish or bearish territory. This indicator/test offers insight into the Exponential Moving Average's velocity and acceleration as well as the Stochastic RSI's velocity, acceleration and jerk. Included is a 'Stochastic Difference' and 'Stochastic Growth' indicators (commented out) that measure the difference between K and D in the Stoch RSI as well as the rate of it's change. This test is all about crossovers - the best leading indicator is a downward cross of the eMA velocity over the eMA acceleration, indicating a drop in price in the current or next bar. The lines or importance have been set to -2 and 5, but these should be adjusted to suit your preferences. These numbers were chosen in order to try and create some kind of threshold after which action might be suggested. Backtesting is highly recommended so you can see how the test does and does not work. It is super powerful, but it is not omniscient - its an RSI and eMA derivative, past success does not necessarily dictate future success. Please look at the code for several more plots you can use of derivatives and other ideas explore but commented out for greater legibility of the graph. Commenting and commenting (or uncommenting all and just disabling some in the settings) and comparing the graphs and crossovers is a useful exercise. To that end, one last concept - the MARSI - a combined moving averages and RSI measurement - was abandoned because it didn't appear to indicate anything of use, however you may find crossovers or patterns with it comparing it to other graphs, so it was left in but commented. Please take a look at the comments and all the math and indicators 'left on the cutting room floor' in the script. Maybe you'll find a gem in the redux version of this script. Outreach regarding the script, patterns noticed and full-on stealing of the script are all permitted. Many elements of this script were nabbed from other scripts - thank you to a community of coders who put it all out there.
Pine Script® göstergesi
BigSwifty tarafından
2
CommonUtils█ OVERVIEW This library is a utility tool for Pine Script™ developers. It provides a collection of helper functions designed to simplify common tasks such as mapping user-friendly string inputs to Pine Script™ constants and formatting timeframe strings for display. The primary goal is to make main scripts cleaner, more readable, and reduce repetitive boilerplate code. It is envisioned as an evolving resource, with potential for new utilities to be added over time based on community needs and feedback. █  CONCEPTS The library primarily focuses on two main concepts: Input Mapping Pine Script™ often requires specific constants for function parameters (e.g., `line.style_dashed` for line styles, `position.top_center` for table positions). However, presenting these technical constants directly to users in script inputs can be confusing. Input mapping involves: Allowing users to select options from more descriptive, human-readable strings (e.g., "Dashed", "Top Center") in the script's settings. Providing functions within this library (e.g., `mapLineStyle`, `mapTablePosition`) that take these user-friendly strings as input. Internally, these functions use switch statements or similar logic to convert (map) the input string to the corresponding Pine Script™ constant required by built-in functions. This approach enhances user experience and simplifies the main script's logic by centralizing the mapping process. Timeframe Formatting Raw timeframe strings obtained from variables like `timeframe.period` (e.g., "1", "60", "D", "W") or user inputs are not always ideal for direct display in labels or panels. The `formatTimeframe` function addresses this by: Taking a raw timeframe string as input. Parsing this string to identify its numerical part and unit (e.g., minutes, hours, days, weeks, months, seconds, milliseconds). Converting it into a more standardized and readable format (e.g., "1min", "60min", "Daily", "Weekly", "1s", "10M"). Offering an optional `customSuffix` parameter (e.g., " FVG", " Period") to append to the formatted string, making labels more descriptive, especially in multi-timeframe contexts. The function is designed to correctly interpret various common timeframe notations used in TradingView. █  NOTES Ease of Use: The library functions are designed with simple and understandable signatures. They typically take a string input and return the corresponding Pine Script™ constant or a formatted string. Default Behaviors: Mapping functions (`mapLineStyle`, `mapTablePosition`, `mapTextSize`) generally return a sensible default value (e.g., `line.style_solid` for `mapLineStyle`) in case of a non-matching input. This helps prevent errors in the main script. Extensibility of Formatting: The `formatTimeframe` function, with its `customSuffix` parameter, allows for flexible customization of timeframe labels to suit the specific descriptive needs of different indicators or contexts. Performance Considerations: These utility functions primarily use basic string operations and switch statements. For typical use cases, their impact on overall script performance is negligible. However, if a function like `formatTimeframe` were to be called excessively in a loop with dynamic inputs (which is generally not its intended use), performance should be monitored. No Dependencies: This library is self-contained and does not depend on any other external Pine Script™ libraries. █  EXPORTED FUNCTIONS mapLineStyle(styleString)   Maps a user-provided line style string to its corresponding Pine Script™ line style constant.   Parameters:      styleString (simple string) : The input string representing the desired line style (e.g., "Solid", "Dashed", "Dotted" - typically from constants like LS1, LS2, LS3).   Returns: The Pine Script™ constant for the line style (e.g., line.style_solid). Defaults to line.style_solid if no match. mapTablePosition(positionString)   Maps a user-provided table position string to its corresponding Pine Script™ position constant.   Parameters:      positionString (simple string) : The input string representing the desired table position (e.g., "Top Right", "Top Center" - typically from constants like PP1, PP2).   Returns: The Pine Script™ constant for the table position (e.g., position.top_right). Defaults to position.top_right if no match. mapTextSize(sizeString)   Maps a user-provided text size string to its corresponding Pine Script™ size constant.   Parameters:      sizeString (simple string) : The input string representing the desired text size (e.g., "Tiny", "Small" - typically from constants like PTS1, PTS2).   Returns: The Pine Script™ constant for the text size (e.g., size.tiny). Defaults to size.small if no match. formatTimeframe(tfInput, customSuffix)   Formats a raw timeframe string into a more display-friendly string, optionally appending a custom suffix.   Parameters:      tfInput (simple string) : The raw timeframe string from user input or timeframe.period (e.g., "1", "60", "D", "W", "1S", "10M", "2H").      customSuffix (simple string) : An optional suffix to append to the formatted timeframe string (e.g., " FVG", " Period"). Defaults to an empty string.   Returns: The formatted timeframe string (e.g., "1min", "60min", "Daily", "Weekly", "1s", "10min", "2h") with the custom suffix appended.
Pine Script® kütüphanesi
no1x tarafından
[blackcat] L2 FiboKAMA Adaptive TrendOVERVIEW The L2 FiboKAMA Adaptive Trend indicator leverages advanced technical analysis techniques by integrating Fibonacci principles with the Kaufman Adaptive Moving Average (KAMA). This combination creates a dynamic and responsive tool designed to adapt seamlessly to changing market conditions. By providing clear buy and sell signals based on adaptive momentum, this indicator helps traders identify potential entry and exit points effectively. Its intuitive design and robust features make it a valuable addition to any trader’s arsenal 📊💹. According to the principle of Kaufman's Adaptive Moving Average (KAMA), it is a type of moving average line specifically designed for markets with high volatility. Unlike traditional moving averages, KAMA can automatically adjust its period based on market conditions to improve accuracy and responsiveness. This makes it particularly useful for capturing market trends and reducing false signals in varying market environments. The use of Fibonacci magic numbers (3, 8, 13) enhances the performance and accuracy of KAMA. These numbers have special mathematical properties that align well with the changing trends of KAMA moving averages. Combining them with KAMA can significantly boost its effectiveness, making it a popular choice among traders seeking reliable signals. This fusion not only smoothens price fluctuations but also ensures quick responses to market changes, offering dependable entry and exit points. Thanks to the flexibility and precision of KAMA combined with Fibonacci magic numbers, traders can better manage risks and aim for higher returns. FEATURES Enhanced Kaufman Adaptive Moving Average (KAMA): Incorporates Fibonacci principles for improved adaptability: Source Price: Allows customization of the price series used for calculation (default: HLCC4). Fast Length: Determines the period for quicker adjustments to recent price changes. Slow Length: Sets the period for smoother transitions over longer-term trends. Dynamic Lines: KAMA Line: A yellow line representing the primary adaptive moving average, which adapts quickly to new trends. Trigger Line: A fuchsia line serving as a reference point for detecting crossovers and generating signals. Visual Cues: Buy Signals: Green 'B' labels indicating potential buying opportunities. Sell Signals: Red 'S' labels signaling possible selling points. Fill Areas: Colored regions between the KAMA and Trigger lines to visually represent trend directions and strength. Alert Functionality: Generates real-time alerts for both buy and sell signals, ensuring timely notifications for actionable insights 🔔. Customizable Parameters: Offers flexibility through adjustable inputs, allowing users to tailor the indicator to their specific trading strategies and preferences. HOW TO USE Adding the Indicator: Open your TradingView chart and navigate to the indicators list. Select L2 FiboKAMA Adaptive Trend and add it to your chart. Configuring Parameters: Adjust the Source Price to choose the desired price series (e.g., close, open, high, low). Set the Fast Length to define how quickly the indicator responds to recent price movements. Configure the Slow Length to determine the smoothness of long-term trend adaptations. Interpreting Signals: Monitor the chart for green 'B' labels indicating buy signals and red 'S' labels for sell signals. Observe the colored fill areas between the KAMA and Trigger lines to gauge trend strength and direction. Setting Up Alerts: Enable alerts within the indicator settings to receive notifications whenever buy or sell signals are triggered. Customize alert messages and frequencies according to your trading plan. Combining with Other Tools: Integrate this indicator with additional technical analysis tools and fundamental research for comprehensive decision-making. Confirm signals using other indicators like RSI, MACD, or Bollinger Bands for increased reliability. Optimizing Performance: Backtest the indicator across various assets and timeframes to understand its behavior under different market conditions. Fine-tune parameters based on historical performance and current market dynamics. Integrating Magic Numbers: Understand the basic principles of KAMA to find suitable entry points for Fibonacci magic numbers. Utilize the efficiency ratio to measure market volatility and adjust moving average parameters accordingly. Apply Fibonacci magic numbers (3, 8, 13) to enhance the responsiveness and accuracy of KAMA. LIMITATIONS Market Volatility: May produce false signals during periods of extreme volatility or sideways movement. Parameter Sensitivity: Requires careful tuning of fast and slow lengths to balance responsiveness and stability. Asset-Specific Behavior: Effectiveness can vary significantly across different financial instruments and time horizons. Complementary Analysis: Should be used alongside other analytical methods to enhance accuracy and reduce risk. NOTES Historical Data: Ensure adequate historical data availability for precise calculations and backtesting. Demo Testing: Thoroughly test the indicator on demo accounts before deploying it in live trading environments. Continuous Learning: Stay updated with market trends and continuously refine your strategy incorporating feedback from the indicator's performance. Risk Management: Always implement proper risk management practices regardless of the signals provided by the indicator. ADVANCED USAGE TIPS Multi-Timeframe Analysis: Apply the indicator across multiple timeframes to gain deeper insights into underlying trends. Divergence Strategy: Look for divergences between price action and the KAMA line to spot potential reversals early. Volume Integration: Combine volume analysis with the indicator to confirm the strength of identified trends. Custom Scripting: Modify the script to include additional filters or conditions tailored to your unique trading approach. IMPROVING KAMA PERFORMANCE Increase Length: Extend the KAMA length to consider more historical data, reducing the impact of short-term price fluctuations. Adjust Fast and Slow Lengths: Make KAMA smoother by increasing the fast length and decreasing the slow length. Use Smoothing Factor: Apply a smoothing factor to control the level of smoothness; typical values range from 0 to 1. Combine with Other Indicators: Pair KAMA with other smoothing indicators like EMA or SMA for more reliable signals. Filter Noise: Use filters or other technical analysis tools to eliminate price noise, enhancing KAMA's effectiveness.
Pine Script® göstergesi
blackcat1402 tarafından
2
Dynamic Customizable 50% Line & Daily High/Low + True Day OpenA Unique Indicator for Precise Market-Level Analysis This indicator is a fully integrated solution that automates complex market-level calculations and visualizations, offering traders a tool that goes beyond the functionality of existing open-source alternatives. By seamlessly combining several trading concepts into a single script, it delivers efficiency, accuracy, and customization that cater to both novice and professional traders. Key Features: A Breakdown of What Makes It Unique 1. Adaptive Daily Highs and Lows Automatically detects and plots daily high and low levels based on the selected time frame, dynamically updating in real time. Features session-based adjustments, allowing traders to focus on levels that matter for specific trading sessions (e.g., London, New York). Fully customizable styling, visibility, and alerts tailored to each trader’s preferences. How It Works: The indicator calculates daily high and low levels directly from price data, integrating session-specific time offsets to account for global trading hours. These levels provide traders with clear visual markers for key liquidity zones. 2. Automated ICT 50% Range Line A pioneering implementation of ICT’s mid-range concept, this feature dynamically calculates and displays the midpoint of the daily range. Offers traders a visual guide to identify premium and discount zones, aiding in determining market bias and potential trade setups. How It Works: The script calculates the range between the day’s high and low, dividing it by two to generate the midline. This line updates in real-time, ensuring that traders always see the most current premium and discount levels as price action evolves. 3. Dynamic Market Open Levels Plots session opens (e.g., Asia, London, New York) and the True Day Open to provide actionable reference points for intra-day trading strategies. Enhances precision in identifying liquidity shifts and aligning trades with institutional price movements. How It Works: The indicator uses predefined session times to calculate and display the opening levels for key trading sessions. It dynamically adjusts for time zones, ensuring accuracy regardless of the trader’s location. 4. Custom Watermark for Enhanced Visualization Includes an optional watermark feature that allows users to display custom text on their charts. Ideal for personalization, branding, or highlighting session notes without disrupting the clarity of the chart. Why This Indicator Stands Out First-to-Market Automation: While the ICT 50% range line is a widely recognized concept, this is the first script to automate its calculation, combining it with other pivotal trading levels in a single tool. All-in-One Functionality: Unlike open-source alternatives that focus on individual features, this script integrates daily highs/lows, mid-range levels, session opens, and customizable watermarks into one cohesive system. The consolidation reduces the need for multiple indicators and ensures a clean, efficient chart setup. Dynamic Customization: Every feature can be adjusted to align with a trader’s strategy, time zone, or aesthetic preferences. This level of adaptability is unmatched in existing tools. Proprietary Logic: The indicator’s underlying calculations are built from scratch, leveraging advanced programming techniques to ensure accuracy and reliability. These proprietary methods differentiate it from similar open-source scripts. How to Use This Indicator Apply the Indicator: Add it to your TradingView chart from the library. Configure Settings: Use the intuitive settings panel to adjust plotted levels, colors, styles, and visibility. Tailor the indicator to your trading strategy. Incorporate into Analysis: Combine the plotted levels with your preferred trading approach to identify liquidity zones, establish market bias, and pinpoint potential reversals or entries. Stay Focused: With all key levels automated and updated in real time, traders can focus on execution rather than manual plotting. Originality and Justification for Closed Source This script is closed-source due to its unique combination of features and proprietary logic that automates complex trading concepts like the ICT 50% range line and session-specific levels. Open-source alternatives lack this level of integration and customization, making this indicator a valuable and original contribution to the TradingView ecosystem. What Sets It Apart from Open-Source Scripts? Unlike open-source tools, this indicator doesn’t just replicate individual features—it enhances and integrates them into a seamless, all-in-one solution that offers traders a more efficient and effective way to analyze the market.
Pine Script® göstergesi
VentureTrading_ tarafından
2
Fibonacci Retracement MTF/LOGIn Pine Script, there’s always a shorter way to achieve a result. As far as I can see, there isn’t an indicator among the community scripts that can produce Fibonacci Retracement levels (linear and logarithmic) as multiple time frame results based on a reference 🍺 This script, which I developed a long time ago, might serve as a starting point to fill this gap. OVERVIEW This indicator is a short and simple script designed to display Fibonacci Retracement levels on the chart according to user preferences, aiming to build the structure of support and resistance. ORIGINALITY This script: Can calculate 'retracement' results from higher time frames. Can recall previous time frame results using its reference parameter. Performs calculations based on both linear and logarithmic scales. Offers optional multipliers and appearance settings to simplify users’ tasks CONCEPTS Fibonacci Retracement is a technical analysis tool used to predict potential reversal points in an asset's price after a significant movement. This indicator identifies possible support and resistance levels by measuring price movements between specific points in a trend, using certain ratios derived from the Fibonacci sequence. It is based on impulsive price actions. MECHANICS This indicator first identifies the highest and lowest prices in the time frame specified by the user. Next, it determines the priority order of the bars where these prices occurred. Finally, it defines the trend direction. Once the trend direction is determined, the "Retracement" levels are constructed. FUNCTIONS The script contains two functions: f_ret(): Generates levels based on the multiplier parameter. f_print(): Handles the visualization by drawing the levels on the chart and positioning the labels in alignment with the levels. It utilizes parameters such as ordinate, confirmation, multiplier, and color for customization NOTES The starting bar for the time frame entered by the user must exist on the chart. Otherwise, the trend direction cannot be determined correctly, and the levels may be drawn inaccurately. This is also mentioned in the tooltip of the TimeFrame parameter. I hope it helps everyone. Do not forget to manage your risk. And trade as safely as possible. Best of luck!
Pine Script® göstergesi
dg_factor tarafından
24
Black-Scholes option price model & delta hedge strategyBlack-Scholes Option Pricing Model Strategy The strategy is based on the Black-Scholes option pricing model and allows the calculation of option prices, various option metrics (the Greeks), and the creation of synthetic positions through delta hedging. ATTENTION! Trading derivative financial instruments involves high risks. The author of the strategy is not responsible for your financial results! The strategy is not self-sufficient for generating profit! It is created exclusively for constructing a synthetic derivative financial instrument. Also, there might be errors in the script, so use it at your own risk! I would appreciate it if you point out any mistakes in the comments! I would be even more grateful if you send the corrected code! Application Scope This strategy can be used for delta hedging short positions in sold options. For example, suppose you sold a call option on Bitcoin on the Deribit exchange with a strike price of $60,000 and an expiration date of September 27, 2024. Using this script, you can create a delta hedge to protect against the risk of loss in the option position if the price of Bitcoin rises. Another example: Suppose you use staking of altcoins in your strategies, for which options are not available. By using this strategy, you can hedge the risk of a price drop (Put option). In this case, you won't lose money if the underlying asset price increases, unlike with a short futures position. Another example: You received an airdrop, but your tokens will not be fully unlocked soon. Using this script, you can fully hedge your position and preserve their dollar value by the time the tokens are fully unlocked. And you won't fear the underlying asset price increasing, as the loss in the event of a price rise is limited to the option premium you will pay if you rebalance the portfolio. Of course, this script can also be used for simple directional trading of momentum and mean reversion strategies! Key Features and Input Parameters 1. Option settings: - Style of option: "European vanilla", "Binary", "Asian geometric". - Type of option: "Call" (bet on the rise) or "Put" (bet on the fall). - Strike price: the option contract price. - Expiration: the expiry date and time of the option contract. 2. Market statistic settings: - Type of price source: open, high, low, close, hl2, hlc3, ohlc4, hlcc4 (using hl2, hlc3, ohlc4, hlcc4 allows smoothing the price in more volatile series). - Risk-free return symbol: the risk-free rate for the market where the underlying asset is traded. For the cryptocurrency market, the return on the funding rate arbitrage strategy is accepted (a special function is written for its calculation based on the Premium Price). - Volatility calculation model: realized (standard deviation over a moving period), implied (e.g., DVOL or VIX), or custom (you can specify a specific number in the field below). For the cryptocurrency market, the calculation of implied volatility is implemented based on the product of the realized volatility ratio of the considered asset and Bitcoin to the Bitcoin implied volatility index. - User implied volatility: fixed implied volatility (used if "Custom" is selected in the "Volatility Calculation Method"). 3. Display settings: - Choose metric: what to display on the indicator scale – the price of the underlying asset, the option price, volatility, or Greeks (all are available). - Measure: bps (basis points), percent. This parameter allows choosing the unit of measurement for the displayed metric (for all except the Greeks). 4. Trading settings: - Hedge model: None (do not trade, default), Simple (just open a position for the full volume when the strike price is crossed), Synthetic option (creating a synthetic option based on the Black-Scholes model). - Position side: Long, Short. - Position size: the number of units of the underlying asset needed to create the option. - Strategy start time: the moment in time after which the strategy will start working to create a synthetic option. - Delta hedge interval: the interval in minutes for rebalancing the portfolio. For example, a value of 5 corresponds to rebalancing the portfolio every 5 minutes. Post scriptum My strategy based on the SegaRKO model. Many thanks to the author! Unfortunately, I don't have enough reputation points to include a link to the author in the description. You can find the original model via the link in the code, as well as through the search indicators on the charts by entering the name: "Black-Scholes Option Pricing Model". I have significantly improved the model: the calculation of volatility, risk-free rate and time value of the option have been reworked. The code performance has also been significantly optimized. And the most significant change is the execution, with which you can now trade using this script.
Pine Script® stratejisi
tonymontanov tarafından
Helacator Ai ThetaHelacator Ai Theta is a state-of-the-art advanced script. It helps the trader find the possibility of a trend reversal in the market. By finding that point at which the three black crows pattern combines with the three white soldiers pattern, it is the most cherished pattern in technical analysis for its signal of strong bullish or bearish momentum. Therefore, it is a very strong predictive tool in the ability of shifting markets. Key Highlights: Three White Soldiers and Three Black Crows Patterns The script identifies these candlestick formations that consist of three consecutive candles, either bullish (Three White Soldiers) or bearish (Three Black Crows). These patterns help the trader identify possible trend reversal points as they provide an early signal of a change in the market direction. It is with great care that the script is written to evaluate the position and relationship between the candlesticks for maintaining the accuracy of pattern recognition. Moving Averages for Trend Filtering: Two important ones used are moving averages for filtering any signals not in accordance with the general trend. The length of these MAs is variable, allowing the traders to be in a position to adapt the script for use under different market conditions. The moving averages ensure that signals are only taken in the direction that supports the general market flow, so it leads to more reliability within the signals. The MAs are not plotted on the chart for the sake of clarity, but they still perform a crucial function in signal filtering and can be displayed optionally for a more detailed investigation. Cooldown filter to reduce over-trading This is part of what is implemented in the script to prevent generation of consecutive signals too quickly. All this helps to reduce market noise and not overtrade—only when market conditions are at their best. The cooldown period can be set to be adjusted according to the trader's preference, making the script more versatile in its use. Practical Considerations: Educational Purpose: This script is for educational purposes only and should be part of a comprehensive trading approach. Proper risk management techniques should be observed while at the same time taking into consideration prevailing market conditions before making any trading decision. No Guaranteed Results: The script is aimed at bringing signal accuracy into improvement to align with the broader market trend and reducing noise, but past performance cannot guarantee future success. Traders should use this script within their broad trading approach. Clean and Simple Chart Display: The primary goal of this script is to have a clear and simple display on the chart. The signals are prominently marked with "BUY" and "SELL," and the color of the bars has changed according to the last signal, thus traders can easily read the output. Community and Open Source Open Source Contribution: This script is open for contribution by the TradingView community. Any suggestions regarding improvements are highly welcomed. Candlestick patterns, moving averages, and the combination of the cooldown filter are presented in such a way as to give traders something special, and any modifications or extra touch by the community is appreciated. Attribution and Transparency: The script is based on standard technical analysis principles and for all parts inspired by or derivated from other available open-source scripts, credit is given where it is due. In this way, transparency ensures that the script adheres to TradingView's standards and promotes a collaborative community environment.
Pine Script® göstergesi
cowdaprettylad tarafından
6
Dynamic Cycle Oscillator [Quantigenics]This script is designed to navigate through the ebbs and flows of financial markets. At its core, this script is a sophisticated yet user-friendly tool that helps you identify potential market turning points and trend continuations. How It Works: The script operates by plotting two distinct lines and a central histogram that collectively form a band structure: a center line and two outer boundaries, indicating overbought and oversold conditions. The lines are calculated based on a blend of exponential moving averages, which are then refined by a root mean square (RMS) over a specified number of bars to establish the cyclic envelope. The input parameters: Fast and Slow Periods: These determine the sensitivity of the script. Shorter periods react quicker to price changes, while longer periods offer a smoother view. RMS Length: This parameter controls the range of the cyclic envelope, influencing the trigger levels for trading signals. Using the Script: On your chart, you’ll notice how the Dynamic Cycle Oscillator’s lines and histogram weave through the price action. Here’s how to interpret the movements. Breakouts and Continuations: Buy Signal: Consider a long position when the histogram crosses above the upper boundary. This suggests a possible strong bullish run. Sell Signal: Consider a short position when the histogram crosses below the lower boundary. This suggests a possible strong bearish run. Reversals: Buy Signal: Consider a long position when the histogram crosses above the lower boundary. This suggests an oversold market turning bullish. Sell Signal: Consider a short position when the histogram crosses below the upper boundary. This implies an overbought market turning bearish. The script’s real-time analysis can serve as a robust addition to your trading strategy, offering clarity in choppy markets and an edge in trend-following systems. Thanks! Hope you enjoy!
Pine Script® göstergesi
Quantigenics tarafından
Triple MA HTF Indicator - Dynamic SmoothingThe indicator version of the "Triple MA HTF Strategy - Dynamic Smoothing" strategy script. In summary the indicator consist of 3 higher time frame moving averages. In which the highest timeframe is used for confirmation on the trend (filter). Moving average 1 and 2 are used to enter and exit the trade (crossover / crossunder). The main principle is to detect momentum when the faster MA 1 crosses the slower MA 2 and only trade with the trend (MA3). The dynamic smoothing in the code makes the indicator suitable to trade on lower tramecharts. The indicator script comes with the following features: options for different types of MA. options to choose from different timeframes & select # bars of that timeframe to calculate the MA value. visualizations of the MA using Dynamic Smoothing calculations on lower timecharts. Note that the chart opened should be lower than the selected timeframes in the configurations. Alerts for entry long, shorts and exits. For more details on the script and possibility for backtesting the Triple MA HTF indicator I refer to my earlier published strategy script:
Pine Script® göstergesi
Harrocop tarafından
Buy Sell Volume SeparateDescription: The script is designed to provide traders with a unique and comprehensive analysis of trading volume dynamics. Unlike existing scripts, the script offers a distinct advantage by presenting both buy and sell volumes on separate scales, simplifying trading decisions. Key Features: 1. Dual Volume Scales: The script provides two separate volume scales, one for buy volumes and another for sell volumes. This separation allows to easily distinguish between buying and selling pressure, aiding in more precise trade entries and exits. 2. Clear and Intuitive Chart: The script ensures that the chart it generates is clean and easy to understand. The buy and sell volumes are color-coded for clarity, and you can quickly identify significant volume spikes and trends. How to Use: 1. Adding the Script: To use the script, simply add it to your TradingView chart. 2. Interpreting Buy and Sell Volumes: On the chart, you will see two separate volume scales—one for buy volumes and one for sell volumes. Green bars represent buying pressure, while red bars indicate selling pressure. Pay attention to the relative strengths and patterns of these bars to gauge market sentiment. 3. Informed Trading Decisions: Armed with insights into both buy and sell volumes, you can make more informed trading decisions. Look for divergences, patterns, or significant volume spikes to identify potential entry and exit points.
Pine Script® göstergesi
fatality14nik tarafından
9
Risk Management and Positionsize - MACD exampleMastering Risk Management Risk management is the cornerstone of successful trading, and it's often the difference between turning a profit and suffering a loss. In light of its importance, I share a risk management tool which you can use for your trading strategies. The script not only assists in position sizing but also comes with built-in technical features that help in market timing. Let's delve into the nitty-gritty details. Input Parameter: MarginFactor One of the key features of the script is the MarginFactor input parameter. This element lets you control the portion of your equity used for placing each trade. A MarginFactor of -0.5 means 50% of your total equity will be deployed in placing the position size. Although Tradingview has a built-in option to adjust position sizing in a same way, I personally prefer to have the logic in my pinecode script. The main reason is userexperience in managing and testing different settings for different charts, timeframes and instruments (with the same strategy). Stoploss and MarginFactor If your strategy has a 4% stop-loss, you can choose to use only 50% of your equity by setting the MarginFactor to -0.5. In this case, you are effectively risking only 2% of your total capital per trade, which aligns well with the widely-accepted rule of thumb suggesting a 1-2% risk per trade. Similar if your stoploss is only 1% you can choose to change the MarginFactor to 1, resulting in a positionsize of 200% of your equity. The total risk would be again 2% per trade if your stoploss is set to 1%. Max Drawdown and MarginFactor Your MarginFactor setting can also be aligned with the maximum drawdown of your strategy, seen during a backtested period of 2-3 years. For example, if the max drawdown is 15%, you could calibrate your MarginFactor accordingly to limit your risk exposure. Option to Toggle Number of Contracts The script offers the option to toggle between using a percentage of equity for position sizing or specifying a fixed number of contracts. Utilizing a percentage of equity might yield unrealistic backtest results, especially over longer periods. This occurs because as the capital grows, the absolute position size also increases, potentially inflating the accumulated returns generated by the backtester. On the other hand, setting a fixed number of contracts as your position size offers a more stable and realistic ROI over the backtested period, as it removes the compounding effect on position sizes. Key Features Strategy MACD High Time Frame Entry and Exit Logic The strategy employs a high time frame MACD (Moving Average Convergence Divergence) to make entry and exit decisions. You can easily adjust the timeframe settings and MACD settings in the inputsection to trade on lower timeframes. For more information on the HTF MACD with dynamic smoothing see: Moving Average High Time Frame Filter To reduce market 'noise', the strategy incorporates a high time frame moving average filter. This ensures that the trades are aligned with the dominant market trend (trading the trend). In the inputsection traders can easily switch between different type of moving averages. For more information about this HTF filter see: Dynamic Smoothing The script includes a feature for dynamic smoothing. The script contains The timeframeToMinutes(tf) function to convert any given time frame into its equivalent in minutes. For example, a daily (D) time frame is converted into 1440 minutes, a weekly (W) into 10,080 minutes, and so forth. Next the smoothing factor is calculated by dividing the minutes of the higher time frame by those of the current time frame. Finally, the script applies a Simple Moving Average (SMA) over the MACD, SIGNAL, and HIST values, MA filter using the dynamically calculated smoothing factor. User Convenience: One of the major benefits is that traders don't need to manually adjust the smoothing factor when switching between different time frames. The script does this dynamically. Visual Consistency: Dynamic smoothing helps traders to more accurately visualize and interpret HTF indicators when trading on lower time frames. Time Frame Restriction: It's crucial to note that the operational time frame should always be lower than the time frame selected in the input sections for dynamic smoothing to function as intended. By incorporating this dynamic smoothing logic, the script offers traders a nuanced yet straightforward way to adapt High Time Frame indicators for lower time frame trading, enhancing both adaptability and user experience. Limitations: Exit Strategy It's crucial to note that the script comes with a simplified exit strategy, devoid of features like a stop-loss, trailing stop-loss or multiple take profits. This means that while the script focuses on entries and risk management, it might result in higher losses if market conditions unexpectedly turn unfavorable. Conclusion Effective risk management is pivotal for trading success, and this TradingView script is designed to give you a better idea how to implement positions sizing with your preferred strategy. However, it's essential to note that this tool should not be considered financial advice. Always perform your due diligence and consult with financial advisors before making any trading decisions. Feel free to use this risk management tool as building block in your trading scripts, Happy Trading!
Pine Script® stratejisi
Harrocop tarafından
4